home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1994 August / August CD.bin / Shareware / Programming / SpriteWorld / Sources / SpriteCompiler.c < prev    next >
Text File  |  1994-03-24  |  18KB  |  931 lines
  1. ///-------------------------------------------------------------------------------------
  2. //    SpriteCompiler.c
  3. //
  4. //    Created:    1/17/94
  5. //    By:            Tony Myles
  6. //
  7. //    Copyright: © 1994 Tony Myles, All rights reserved worldwide
  8. //
  9. //    Description:    constants, structures, and prototypes for the sprite compiler
  10. ///--------------------------------------------------------------------------------------
  11.  
  12.  
  13. #ifndef __SWCOMMON__
  14. #include "SWCommonHeaders.h"
  15. #endif
  16.  
  17. #ifndef __TYPES__
  18. #include <Types.h>
  19. #endif
  20.  
  21. #ifndef __MEMORY__
  22. #include <Memory.h>
  23. #endif
  24.  
  25. #ifndef __RESOURCES__
  26. #include <Resources.h>
  27. #endif
  28.  
  29. #ifndef __QUICKDRAW__
  30. #include <QuickDraw.h>
  31. #endif
  32.  
  33. #ifndef __DEBUGUTILS__
  34. #include "DebugUtils.h"
  35. #endif
  36.  
  37. #ifndef __SPRITE__
  38. #include "Sprite.h"
  39. #endif
  40.  
  41. #ifndef __SPRITEWORLDUTILS__
  42. #include "SpriteWorldUtils.h"
  43. #endif
  44.  
  45. #ifndef __SPRITECOMPILER__
  46. #include "SpriteCompiler.h"
  47. #endif
  48.  
  49.  
  50.  
  51. OSErr SWCompileColorIconResource(
  52.     short iconResID,
  53.     PixelCodeHdl* newPixCodeH)
  54. {
  55.     OSErr err;
  56.     GrafPtr savePort;
  57.     CGrafPtr newGrafPort;
  58.     CGrafPtr maskGrafPort;
  59.     CIconHandle cIconH;
  60.     Rect cIconRect;
  61.  
  62.     *newPixCodeH = NULL;
  63.     newGrafPort = NULL;
  64.     maskGrafPort = NULL;
  65.     cIconH = NULL;
  66.  
  67.     GetPort(&savePort);
  68.  
  69.     err = SWGetCIcon(&cIconH, iconResID);
  70.  
  71.     if (err == noErr)
  72.     {
  73.         HNoPurge((Handle)cIconH);
  74.  
  75.         cIconRect = (**cIconH).iconPMap.bounds;
  76.  
  77.         err = SWCreateBestCGrafPort(&newGrafPort, &cIconRect);
  78.     }
  79.  
  80.     if (err == noErr)
  81.     {
  82.         SetPort((GrafPtr)newGrafPort);
  83.  
  84.         SWPlotCIcon(cIconH, &cIconRect);
  85.     }
  86.  
  87.     if (err == noErr)
  88.     {
  89.         err = SWCreateCGrafPortFromCIconMask(&maskGrafPort, cIconH);
  90.     }
  91.  
  92.     if (err == noErr)
  93.     {
  94.         err = SWParsePixels(newGrafPort->portPixMap, maskGrafPort->portPixMap, newPixCodeH);
  95.     }
  96.  
  97.     if (cIconH != NULL)
  98.     {
  99.         SWDisposeCIcon(cIconH);
  100.     }
  101.  
  102.     if (newGrafPort != NULL)
  103.     {
  104.         SWDisposeCGrafPort(newGrafPort);
  105.     }
  106.  
  107.     if (maskGrafPort != NULL)
  108.     {
  109.         SWDisposeCGrafPort(maskGrafPort);
  110.     }
  111.  
  112.     SetPort(savePort);
  113.  
  114.     return err;
  115. }
  116.  
  117.  
  118. OSErr SWParsePixels(
  119.     PixMapHandle srcPixMapH,
  120.     PixMapHandle maskPixMapH,
  121.     PixelCodeHdl* newPixCodeH)
  122. {
  123.     OSErr err = noErr;
  124.     PixelCodeHdl tempPixCodeH;
  125.  
  126.     *newPixCodeH = NULL;
  127.  
  128.     tempPixCodeH = (PixelCodeHdl)NewHandle(0);
  129.  
  130.     if (tempPixCodeH != NULL)
  131.     {
  132.         long scanLine;
  133.         long numberOfScanLines = (**srcPixMapH).bounds.bottom - (**srcPixMapH).bounds.top;
  134.         long pixelsPerScanLine = (**srcPixMapH).rowBytes & 0x7FFF;
  135.         Ptr srcBaseAddrP, maskBaseAddrP;
  136.  
  137.         srcBaseAddrP = (**srcPixMapH).baseAddr;
  138.         maskBaseAddrP = (**maskPixMapH).baseAddr;
  139.  
  140.         err = SWGeneratePreamble(tempPixCodeH);
  141.  
  142.         for (scanLine = 0; (err == noErr) && (scanLine < numberOfScanLines); scanLine++)
  143.         {
  144.             err = SWCompileMaskScanLine(tempPixCodeH, maskBaseAddrP, pixelsPerScanLine, scanLine == (numberOfScanLines-1));
  145.  
  146.             if (err == noErr)
  147.             {
  148.                 srcBaseAddrP += pixelsPerScanLine;
  149.                 maskBaseAddrP += pixelsPerScanLine;
  150.             }
  151.         }
  152.  
  153.         if (err == noErr)
  154.         {
  155.             err = SWGeneratePostamble(tempPixCodeH);
  156.         }
  157.  
  158.         if (err == noErr)
  159.             *newPixCodeH = tempPixCodeH;
  160.     }
  161.     else
  162.     {
  163.         err = MemError();
  164.     }
  165.  
  166.     return err;
  167. }
  168.  
  169.  
  170. OSErr SWGeneratePreamble(PixelCodeHdl srcPixCodeH)
  171. {
  172.     OSErr err = noErr;
  173.     Size curHandleSize;
  174.     unsigned char* scanCodeP;
  175.  
  176.     curHandleSize = GetHandleSize((Handle)srcPixCodeH);
  177.     err = MemError();
  178.  
  179.     if (err == noErr)
  180.     {
  181.         SetHandleSize((Handle)srcPixCodeH, curHandleSize + 10);
  182.         err = MemError();
  183.     }
  184.  
  185.     if (err == noErr)
  186.     {
  187.         scanCodeP = ((unsigned char*)*srcPixCodeH) + curHandleSize;
  188.         
  189.             //48E7 1F3E          MOVEM.L   D3-D7/A2-A6,-(A7)
  190.         *(unsigned long*)scanCodeP = 0x48E71F3E;
  191.         scanCodeP += 4;
  192.  
  193.             //4CEF 0303 002C     MOVEM.L   $002C(A7),D0/D1/A0/A1
  194.         *(unsigned long*)scanCodeP = 0x4CEF0303;
  195.         scanCodeP += 4;
  196.  
  197.         *(unsigned short*)scanCodeP = 0x002C;
  198.         scanCodeP += 2;
  199.     }
  200.  
  201.     return err;
  202. }
  203.  
  204. /*
  205. 00000000: 48E7 1F3E          MOVEM.L   D3-D7/A2-A6,-(A7)
  206. 00000004: 4CEF 0303 002C     MOVEM.L   $002C(A7),D0/D1/A0/A1
  207. 0000000A: 4E92               JSR       (A2)
  208. 0000000C: 4CDF 7CF8          MOVEM.L   (A7)+,D3-D7/A2-A6
  209. 00000010: 4E75               RTS
  210. */
  211.  
  212. OSErr SWGeneratePostamble(PixelCodeHdl srcPixCodeH)
  213. {
  214.     OSErr err = noErr;
  215.     Size curHandleSize;
  216.     unsigned char* scanCodeP;
  217.  
  218.     curHandleSize = GetHandleSize((Handle)srcPixCodeH);
  219.     err = MemError();
  220.  
  221.     if (err == noErr)
  222.     {
  223.         SetHandleSize((Handle)srcPixCodeH, curHandleSize + 6);
  224.         err = MemError();
  225.     }
  226.  
  227.     if (err == noErr)
  228.     {
  229.         scanCodeP = ((unsigned char*)*srcPixCodeH) + curHandleSize;
  230.         
  231.             //4CDF 7CF8          MOVEM.L   (A7)+,D3-D7/A2-A6
  232.         *(unsigned long*)scanCodeP = 0x4CDF7CF8;
  233.         scanCodeP += 4;
  234.  
  235.             //4E75               RTS
  236.         *(unsigned short*)scanCodeP = 0x4E75;
  237.         scanCodeP += 2;
  238.     }
  239.  
  240.     return err;
  241. }
  242.  
  243.  
  244.  
  245. OSErr SWCompileMaskScanLine(
  246.     PixelCodeHdl newPixCodeH,
  247.     Ptr maskPixelP,
  248.     long numberOfPixels,
  249.     Boolean isLastScanLine)
  250. {
  251.     OSErr err = noErr;
  252.     Size curHandleSize;
  253.     unsigned char* scanCodeP;
  254.     unsigned char* maskScanPixelP = (unsigned char*)maskPixelP;
  255.     Size codeSize;
  256.     long pixelsToScan;
  257.     unsigned short numPixelsToBlit;
  258.     unsigned short pixelOffset;
  259.  
  260.     curHandleSize = GetHandleSize((Handle)newPixCodeH);
  261.     err = MemError();
  262.  
  263.     if (err == noErr)
  264.     {
  265.         SetHandleSize((Handle)newPixCodeH, curHandleSize + (numberOfPixels * kMaxInstructionSize) + 4);
  266.         err = MemError();
  267.     }
  268.  
  269.     if (err == noErr)
  270.     {
  271.         scanCodeP = ((unsigned char*)*newPixCodeH) + curHandleSize;
  272.         codeSize = curHandleSize;
  273.         pixelOffset = 0;
  274.         pixelsToScan = numberOfPixels;
  275.  
  276.         while (pixelsToScan)
  277.         {
  278.             numPixelsToBlit = 0;
  279.  
  280.                 // scan for pixels to blit
  281.             while (pixelsToScan && *maskScanPixelP)
  282.             {
  283.                 maskScanPixelP++;
  284.                 numPixelsToBlit++;
  285.                 pixelsToScan--;
  286.             }
  287.  
  288.                 // generate code for the pixel run
  289.             while (numPixelsToBlit)
  290.             {
  291.                 if (numPixelsToBlit >= 44)
  292.                 {
  293.                     if (pixelOffset)
  294.                     {
  295.                             //4CE8 7CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2-A6
  296.                             //48E9 7CFC 0042     MOVEM.L   D2-D7/A2-A6,$0042(A1)
  297.  
  298.                         *(unsigned long*)scanCodeP = 0x4CE87CFC;
  299.                         scanCodeP += 4;
  300.     
  301.                         *(unsigned short*)scanCodeP = pixelOffset;
  302.                         scanCodeP += 2;
  303.     
  304.                         *(unsigned long*)scanCodeP = 0x48E97CFC;
  305.                         scanCodeP += 4;
  306.     
  307.                         *(unsigned short*)scanCodeP = pixelOffset;
  308.                         scanCodeP += 2;
  309.  
  310.                         codeSize += 12;
  311.                     }
  312.                     else
  313.                     {
  314.                             //4CD0 7CFC          MOVEM.L   (A0),D2-D7/A2-A6
  315.                             //48D1 7CFC          MOVEM.L   D2-D7/A2-A6,(A1)
  316.  
  317.                         *(unsigned long*)scanCodeP = 0x4CD07CFC;
  318.                         scanCodeP += 4;
  319.     
  320.                         *(unsigned long*)scanCodeP = 0x48D17CFC;
  321.                         scanCodeP += 4;
  322.  
  323.                         codeSize += 8;
  324.                     }
  325.  
  326.                     pixelOffset += 44;
  327.                     numPixelsToBlit -= 44;
  328.                 }
  329.                 else if (numPixelsToBlit >= 40)
  330.                 {
  331.                     if (pixelOffset)
  332.                     {
  333.                             //4CD0 3CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2-A5
  334.                             //48D1 3CFC 0042     MOVEM.L   D2-D7/A2-A5,$0042(A1)
  335.                         *(unsigned long*)scanCodeP = 0x4CE83CFC;
  336.                         scanCodeP += 4;
  337.     
  338.                         *(unsigned short*)scanCodeP = pixelOffset;
  339.                         scanCodeP += 2;
  340.     
  341.                         *(unsigned long*)scanCodeP = 0x48E93CFC;
  342.                         scanCodeP += 4;
  343.     
  344.                         *(unsigned short*)scanCodeP = pixelOffset;
  345.                         scanCodeP += 2;
  346.  
  347.                         codeSize += 12;
  348.                     }
  349.                     else
  350.                     {
  351.                             //4CD0 3CFC     MOVEM.L   (A0),D2-D7/A2-A5
  352.                             //48D1 3CFC     MOVEM.L   D2-D7/A2-A5,(A1)
  353.     
  354.                         *(unsigned long*)scanCodeP = 0x4CD03CFC;
  355.                         scanCodeP += 4;
  356.     
  357.                         *(unsigned long*)scanCodeP = 0x48D13CFC;
  358.                         scanCodeP += 4;
  359.     
  360.                         codeSize += 8;
  361.                     }
  362.  
  363.                     pixelOffset += 40;
  364.                     numPixelsToBlit -= 40;
  365.                 }
  366.                 else if (numPixelsToBlit >= 36)
  367.                 {
  368.                     if (pixelOffset)
  369.                     {
  370.                             //4CE8 1CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2-A4
  371.                             //48E9 1CFC 0042     MOVEM.L   D2-D7/A2-A4,$0042(A1)
  372.     
  373.                         *(unsigned long*)scanCodeP = 0x4CE81CFC;
  374.                         scanCodeP += 4;
  375.     
  376.                         *(unsigned short*)scanCodeP = pixelOffset;
  377.                         scanCodeP += 2;
  378.     
  379.                         *(unsigned long*)scanCodeP = 0x48E91CFC;
  380.                         scanCodeP += 4;
  381.     
  382.                         *(unsigned short*)scanCodeP = pixelOffset;
  383.                         scanCodeP += 2;
  384.  
  385.                         codeSize += 12;
  386.                     }
  387.                     else
  388.                     {
  389.                             //4CD0 1CFC     MOVEM.L   (A0),D2-D7/A2-A4
  390.                             //48D1 1CFC     MOVEM.L   D2-D7/A2-A4,(A1)
  391.     
  392.                         *(unsigned long*)scanCodeP = 0x4CD01CFC;
  393.                         scanCodeP += 4;
  394.     
  395.                         *(unsigned long*)scanCodeP = 0x48D11CFC;
  396.                         scanCodeP += 4;
  397.     
  398.                         codeSize += 8;
  399.                     }
  400.  
  401.                     pixelOffset += 36;
  402.                     numPixelsToBlit -= 36;
  403.                 }
  404.                 else if (numPixelsToBlit >= 32)
  405.                 {
  406.                     if (pixelOffset)
  407.                     {
  408.                             //4CD0 0CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2/A3
  409.                             //48D1 0CFC 0042     MOVEM.L   D2-D7/A2/A3,$0042(A1)
  410.  
  411.                         *(unsigned long*)scanCodeP = 0x4CE80CFC;
  412.                         scanCodeP += 4;
  413.     
  414.                         *(unsigned short*)scanCodeP = pixelOffset;
  415.                         scanCodeP += 2;
  416.     
  417.                         *(unsigned long*)scanCodeP = 0x48E90CFC;
  418.                         scanCodeP += 4;
  419.     
  420.                         *(unsigned short*)scanCodeP = pixelOffset;
  421.                         scanCodeP += 2;
  422.  
  423.                         codeSize += 12;
  424.                     }
  425.                     else
  426.                     {
  427.                             //4CD0 0CFC     MOVEM.L   (A0),D2-D7/A2/A3
  428.                             //48D1 0CFC     MOVEM.L   D2-D7/A2/A3,(A1)
  429.     
  430.                         *(unsigned long*)scanCodeP = 0x4CD00CFC;
  431.                         scanCodeP += 4;
  432.     
  433.                         *(unsigned long*)scanCodeP = 0x48D10CFC;
  434.                         scanCodeP += 4;
  435.     
  436.                         codeSize += 8;
  437.                     }
  438.  
  439.                     pixelOffset += 32;
  440.                     numPixelsToBlit -= 32;
  441.                 }
  442.                 else if (numPixelsToBlit >= 28)
  443.                 {
  444.                     if (pixelOffset)
  445.                     {
  446.                             //4CE8 04FC 0042     MOVEM.L   $0042(A0),D2-D7/A2
  447.                             //48E9 04FC 0042     MOVEM.L   D2-D7/A2,$0042(A1)
  448.     
  449.                         *(unsigned long*)scanCodeP = 0x4CE804FC;
  450.                         scanCodeP += 4;
  451.     
  452.                         *(unsigned short*)scanCodeP = pixelOffset;
  453.                         scanCodeP += 2;
  454.     
  455.                         *(unsigned long*)scanCodeP = 0x48E904FC;
  456.                         scanCodeP += 4;
  457.     
  458.                         *(unsigned short*)scanCodeP = pixelOffset;
  459.                         scanCodeP += 2;
  460.  
  461.                         codeSize += 12;
  462.                     }
  463.                     else
  464.                     {
  465.                             //4CD0 04FC     MOVEM.L   (A0),D2-D7/A2
  466.                             //48D1 04FC     MOVEM.L   D2-D7/A2,(A1)
  467.     
  468.                         *(unsigned long*)scanCodeP = 0x4CD004FC;
  469.                         scanCodeP += 4;
  470.     
  471.                         *(unsigned long*)scanCodeP = 0x48D104FC;
  472.                         scanCodeP += 4;
  473.     
  474.                         codeSize += 8;
  475.                     }
  476.  
  477.                     pixelOffset += 28;
  478.                     numPixelsToBlit -= 28;
  479.                 }
  480.                 else if (numPixelsToBlit >= 24)
  481.                 {
  482.                     if (pixelOffset)
  483.                     {
  484.                             //4CE8 00FC 0042     MOVEM.L   $0042(A0),D2-D7
  485.                             //48E9 00FC 0042     MOVEM.L   D2-D7,$0042(A1)
  486.                         *(unsigned long*)scanCodeP = 0x4CE800FC;
  487.                         scanCodeP += 4;
  488.     
  489.                         *(unsigned short*)scanCodeP = pixelOffset;
  490.                         scanCodeP += 2;
  491.     
  492.                         *(unsigned long*)scanCodeP = 0x48E900FC;
  493.                         scanCodeP += 4;
  494.     
  495.                         *(unsigned short*)scanCodeP = pixelOffset;
  496.                         scanCodeP += 2;
  497.  
  498.                         codeSize += 12;
  499.                     }
  500.                     else
  501.                     {
  502.                             //4CD0 00FC          MOVEM.L   (A0),D2-D7
  503.                             //48D1 00FC          MOVEM.L   D2-D7,(A1)
  504.                         *(unsigned long*)scanCodeP = 0x4CD000FC;
  505.                         scanCodeP += 4;
  506.     
  507.                         *(unsigned long*)scanCodeP = 0x48D100FC;
  508.                         scanCodeP += 4;
  509.     
  510.                         codeSize += 8;
  511.                     }
  512.  
  513.                     pixelOffset += 24;
  514.                     numPixelsToBlit -= 24;
  515.                 }
  516.                 else if (numPixelsToBlit >= 20)
  517.                 {
  518.                     if (pixelOffset)
  519.                     {
  520.                             //4CE8 007C 0042     MOVEM.L   $0042(A0),D2-D6
  521.                             //48E9 007C 0042     MOVEM.L   D2-D6,$0042(A1)
  522.                         *(unsigned long*)scanCodeP = 0x4CE8007C;
  523.                         scanCodeP += 4;
  524.     
  525.                         *(unsigned short*)scanCodeP = pixelOffset;
  526.                         scanCodeP += 2;
  527.     
  528.                         *(unsigned long*)scanCodeP = 0x48E9007C;
  529.                         scanCodeP += 4;
  530.     
  531.                         *(unsigned short*)scanCodeP = pixelOffset;
  532.                         scanCodeP += 2;
  533.  
  534.                         codeSize += 12;
  535.                     }
  536.                     else
  537.                     {
  538.                             //4CD0 007C          MOVEM.L   (A0),D2-D6
  539.                             //48D1 007C          MOVEM.L   D2-D6,(A1)
  540.                         *(unsigned long*)scanCodeP = 0x4CD0007C;
  541.                         scanCodeP += 4;
  542.     
  543.                         *(unsigned long*)scanCodeP = 0x48D1007C;
  544.                         scanCodeP += 4;
  545.     
  546.                         codeSize += 8;
  547.                     }
  548.  
  549.                     pixelOffset += 20;
  550.                     numPixelsToBlit -= 20;
  551.                 }
  552.                 else if (numPixelsToBlit >= 16)
  553.                 {
  554.                     if (pixelOffset)
  555.                     {
  556.                             //4CE8 003C 0042     MOVEM.L   $0042(A0),D2-D5
  557.                             //48E9 003C 0042     MOVEM.L   D2-D5,$0042(A1)
  558.                         *(unsigned long*)scanCodeP = 0x4CE8003C;
  559.                         scanCodeP += 4;
  560.     
  561.                         *(unsigned short*)scanCodeP = pixelOffset;
  562.                         scanCodeP += 2;
  563.     
  564.                         *(unsigned long*)scanCodeP = 0x48E9003C;
  565.                         scanCodeP += 4;
  566.     
  567.                         *(unsigned short*)scanCodeP = pixelOffset;
  568.                         scanCodeP += 2;
  569.  
  570.                         codeSize += 12;
  571.                     }
  572.                     else
  573.                     {
  574.                             //4CD0 003C     MOVEM.L   (A0),D2-D5
  575.                             //48D1 003C     MOVEM.L   D2-D5,(A1)
  576.                         *(unsigned long*)scanCodeP = 0x4CD0003C;
  577.                         scanCodeP += 4;
  578.     
  579.                         *(unsigned long*)scanCodeP = 0x48D1003C;
  580.                         scanCodeP += 4;
  581.     
  582.                         codeSize += 8;
  583.                     }
  584.  
  585.                     pixelOffset += 16;
  586.                     numPixelsToBlit -= 16;
  587.                 }
  588.                 else if (numPixelsToBlit >= 12)
  589.                 {
  590.                     if (pixelOffset)
  591.                     {
  592.                             //4CE8 001C 0042     MOVEM.L   $0042(A0),D2-D4
  593.                             //48E9 001C 0042     MOVEM.L   D2-D4,$0042(A1)
  594.                         *(unsigned long*)scanCodeP = 0x4CE8001C;
  595.                         scanCodeP += 4;
  596.     
  597.                         *(unsigned short*)scanCodeP = pixelOffset;
  598.                         scanCodeP += 2;
  599.     
  600.                         *(unsigned long*)scanCodeP = 0x48E9001C;
  601.                         scanCodeP += 4;
  602.     
  603.                         *(unsigned short*)scanCodeP = pixelOffset;
  604.                         scanCodeP += 2;
  605.  
  606.                         codeSize += 12;
  607.                     }
  608.                     else
  609.                     {
  610.                             //4CD0 001C     MOVEM.L   (A0),D2-D4
  611.                             //48D1 001C     MOVEM.L   D2-D4,(A1)
  612.                         *(unsigned long*)scanCodeP = 0x4CD0001C;
  613.                         scanCodeP += 4;
  614.     
  615.                         *(unsigned long*)scanCodeP = 0x48D1001C;
  616.                         scanCodeP += 4;
  617.     
  618.                         codeSize += 8;
  619.                     }
  620.  
  621.                     pixelOffset += 12;
  622.                     numPixelsToBlit -= 12;
  623.                 }
  624.                 else if (numPixelsToBlit >= 4)
  625.                 {
  626.                     if (pixelOffset)
  627.                     {
  628.                             //2368 0066 0066     MOVE.L    $0066(A0),$0066(A1)
  629.     
  630.                         *(unsigned short*)scanCodeP = 0x2368;
  631.                         scanCodeP += 2;
  632.     
  633.                         *(unsigned short*)scanCodeP = pixelOffset;
  634.                         scanCodeP += 2;
  635.     
  636.                         *(unsigned short*)scanCodeP = pixelOffset;
  637.                         scanCodeP += 2;
  638.  
  639.                         codeSize += 6;
  640.                     }
  641.                     else
  642.                     {
  643.                             //2290               MOVE.L    (A0),(A1)
  644.  
  645.                         *(unsigned short*)scanCodeP = 0x2290;
  646.                         scanCodeP += 2;
  647.  
  648.                         codeSize += 2;
  649.                     }
  650.  
  651.                     pixelOffset += 4;
  652.                     numPixelsToBlit -= 4;
  653.                 }
  654.                 else if (numPixelsToBlit >= 2)
  655.                 {
  656.                     if (pixelOffset)
  657.                     {
  658.                             //3368 0066 0066     MOVE.W    $0066(A0),$0066(A1)
  659.     
  660.                         *(unsigned short*)scanCodeP = 0x3368;
  661.                         scanCodeP += 2;
  662.     
  663.                         *(unsigned short*)scanCodeP = pixelOffset;
  664.                         scanCodeP += 2;
  665.     
  666.                         *(unsigned short*)scanCodeP = pixelOffset;
  667.                         scanCodeP += 2;
  668.  
  669.                         codeSize += 6;
  670.                     }
  671.                     else
  672.                     {
  673.                             //3290               MOVE.W    (A0),(A1)
  674.  
  675.                         *(unsigned short*)scanCodeP = 0x3290;
  676.                         scanCodeP += 2;
  677.  
  678.                         codeSize += 2;
  679.                     }
  680.  
  681.                     pixelOffset += 2;
  682.                     numPixelsToBlit -= 2;
  683.                 }
  684.                 else if (numPixelsToBlit == 1)
  685.                 {
  686.                     if (pixelOffset)
  687.                     {
  688.                             //1368 0066 0066     MOVE.B    $0066(A0),$0066(A1)
  689.     
  690.                         *(unsigned short*)scanCodeP = 0x1368;
  691.                         scanCodeP += 2;
  692.     
  693.                         *(unsigned short*)scanCodeP = pixelOffset;
  694.                         scanCodeP += 2;
  695.     
  696.                         *(unsigned short*)scanCodeP = pixelOffset;
  697.                         scanCodeP += 2;
  698.  
  699.                         codeSize += 6;
  700.                     }
  701.                     else
  702.                     {
  703.                             //1290               MOVE.B    (A0),(A1)
  704.  
  705.                         *(unsigned short*)scanCodeP = 0x1290;
  706.                         scanCodeP += 2;
  707.  
  708.                         codeSize += 2;
  709.                     }
  710.  
  711.                     pixelOffset++;
  712.                     numPixelsToBlit--;
  713.                 }
  714.             }
  715.  
  716.                 // scan for pixels to skip
  717.             while (pixelsToScan && !*maskScanPixelP)
  718.             {
  719.                 pixelOffset++;
  720.                 maskScanPixelP++;
  721.                 pixelsToScan--;
  722.             }
  723.         }
  724.  
  725.         if (!isLastScanLine)
  726.         {
  727.                 //D1C0               ADDA.L    D0,A0
  728.             *(unsigned short*)scanCodeP = 0xD1C0;
  729.             scanCodeP += 2;
  730.  
  731.                 //D3C1               ADDA.L    D1,A1
  732.             *(unsigned short*)scanCodeP = 0xD3C1;
  733.             scanCodeP += 2;
  734.  
  735.             codeSize += 4;
  736.         }
  737.  
  738.         SetHandleSize((Handle)newPixCodeH, codeSize);
  739.         err = MemError();
  740.     }
  741.  
  742.     return err;
  743. }
  744.  
  745.  
  746. OSErr SWSavePixelCodeResource(
  747.     PixelCodeHdl newPixCodeH,
  748.     short pixCodeResID)
  749. {
  750.     OSErr err = noErr;
  751.     Handle curPixCodeH;
  752.     Str255 resName = "\p";
  753.  
  754.     curPixCodeH = GetResource(kPixelCodeResType, pixCodeResID);
  755.     if (curPixCodeH == NULL)
  756.     {
  757.         curPixCodeH = (Handle)newPixCodeH;
  758.  
  759.         AddResource(curPixCodeH, kPixelCodeResType, pixCodeResID, resName);
  760.         err = ResError();
  761.  
  762.         if (err == noErr)
  763.         {
  764.             WriteResource(curPixCodeH);
  765.             err = ResError();
  766.         }
  767.  
  768.         if (err == noErr)
  769.         {
  770.             DetachResource(curPixCodeH);
  771.             err = ResError();
  772.         }
  773.     }
  774.     else
  775.     {
  776.         Size newHandleSize;
  777.  
  778.         newHandleSize = GetHandleSize((Handle)newPixCodeH);
  779.         err = MemError();
  780.  
  781.         if (err == noErr)
  782.         {
  783.             err = PtrToXHand((Ptr)*newPixCodeH, curPixCodeH, newHandleSize);
  784.         }
  785.  
  786.         if (err == noErr)
  787.         {
  788.             ChangedResource(curPixCodeH);
  789.             err = ResError();
  790.         }
  791.  
  792.         if (err == noErr)
  793.         {
  794.             WriteResource(curPixCodeH);
  795.             err = ResError();
  796.         }
  797.  
  798.         ReleaseResource(curPixCodeH);
  799.     }
  800.  
  801.     return err;
  802. }
  803.  
  804.  
  805. #if 0
  806.  
  807. void x(void);
  808.  
  809. SW_ASM_FUNC void x(void)
  810. {
  811.         SW_ASM_BEGIN
  812.  
  813.         movem.l    d3-d7/a2-a6,-(sp)        // save off regs
  814.         movem.l 44(sp),d0/d1/a0-a1        // blast the parameters into registers (cool!)
  815.         jsr        (a2)                    // jump into the blitter
  816.         movem.l    (sp)+,d3-d7/a2-a6        // restore regs
  817.         rts
  818.  
  819.             // move 44 bytes
  820.         movem.l    66(a0), d2-d7/a2-a6
  821.         movem.l d2-d7/a2-a6, 66(a1)
  822.  
  823.             // move 40 bytes
  824.         movem.l    66(a0), d2-d7/a2-a5
  825.         movem.l d2-d7/a2-a5, 66(a1)
  826.  
  827.             // move 36 bytes
  828.         movem.l    66(a0), d2-d7/a2-a4
  829.         movem.l d2-d7/a2-a4, 66(a1)
  830.  
  831.             // move 32 bytes
  832.         movem.l    66(a0), d2-d7/a2/a3
  833.         movem.l d2-d7/a2/a3, 66(a1)
  834.  
  835.             // move 28 bytes
  836.         movem.l    66(a0), d2-d7/a2
  837.         movem.l d2-d7/a2, 66(a1)
  838.  
  839.             // move 24 bytes
  840.         movem.l    66(a0), d2-d7
  841.         movem.l d2-d7, 66(a1)
  842.  
  843.             // move 20 bytes
  844.         movem.l    66(a0), d2-d6
  845.         movem.l d2-d6, 66(a1)
  846.  
  847.             // move 16 bytes
  848.         movem.l    66(a0), d2-d5
  849.         movem.l d2-d5, 66(a1)
  850.  
  851.             // move 12 bytes
  852.         movem.l    66(a0), d2-d4
  853.         movem.l d2-d4, 66(a1)
  854.  
  855.  
  856.  
  857.             // move 44 bytes (no offset)
  858.         movem.l (a0), d2-d7/a2-a6
  859.         movem.l d2-d7/a2-a6, (a1)
  860.  
  861.             // move 40 bytes
  862.         movem.l    (a0), d2-d7/a2-a5
  863.         movem.l d2-d7/a2-a5, (a1)
  864.  
  865.             // move 36 bytes
  866.         movem.l    (a0), d2-d7/a2-a4
  867.         movem.l d2-d7/a2-a4, (a1)
  868.  
  869.             // move 32 bytes
  870.         movem.l    (a0), d2-d7/a2/a3
  871.         movem.l d2-d7/a2/a3, (a1)
  872.  
  873.             // move 28 bytes
  874.         movem.l    (a0), d2-d7/a2
  875.         movem.l d2-d7/a2, (a1)
  876.  
  877.             // move 24 bytes
  878.         movem.l    (a0), d2-d7
  879.         movem.l d2-d7, (a1)
  880.  
  881.             // move 20 bytes
  882.         movem.l    (a0), d2-d6
  883.         movem.l d2-d6, (a1)
  884.  
  885.             // move 16 bytes
  886.         movem.l    (a0), d2-d5
  887.         movem.l d2-d5, (a1)
  888.  
  889.             // move 12 bytes
  890.         movem.l    (a0), d2-d4
  891.         movem.l d2-d4, (a1)
  892.  
  893.  
  894.  
  895.         move.l    0x66(a0),0x66(a1)
  896.         move.w    0x66(a0),0x66(a1)
  897.         move.b    0x66(a0),0x66(a1)
  898.  
  899.         move.l    (a0),(a1)
  900.         move.w    (a0),(a1)
  901.         move.b    (a0),(a1)
  902.  
  903.         move.l    (a0)+,0x66(a1)
  904.         move.w    (a0)+,0x66(a1)
  905.         move.b    (a0)+,0x66(a1)
  906.  
  907.         move.l    (a0)+,(a1)+
  908.         move.w    (a0)+,(a1)+
  909.         move.b    (a0)+,(a1)+
  910.  
  911.         adda.l    d0, a0
  912.         adda.l    d1, a1
  913.  
  914.         adda.l    a2, a0
  915.         adda.l    a3, a1
  916.  
  917.  
  918.         add.l    #9,a1
  919.         addq.l    #8,a1
  920.         lea        6666(a0),a0
  921.         lea        6666(a1),a1
  922.         lea        6(a1),a1
  923.  
  924.         SW_ASM_END
  925. }
  926.  
  927. #endif
  928.  
  929.  
  930.  
  931.